home *** CD-ROM | disk | FTP | other *** search
/ Netscape Plug-Ins Developer's Kit / Netscape_Plug-Ins_Developers_Kit.iso / CGIPERL / MACPERL / MSRCE418.HQX / Perl Source ƒ / MacPerl / MPFile.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-12-25  |  20.3 KB  |  937 lines
  1. /*********************************************************************
  2. Project    :    MacPerl            -    Real Perl Application
  3. File        :    MPFile.c            -
  4. Author    :    Matthias Neeracher
  5.  
  6. A lot of this code is borrowed from 7Edit written by
  7. Apple Developer Support UK
  8.  
  9. Language    :    MPW C
  10.  
  11. $Log: MPFile.c,v $
  12. Revision 1.1  1994/02/27  23:00:47  neeri
  13. Initial revision
  14.  
  15. Revision 0.6  1993/09/17  00:00:00  neeri
  16. Runtime version
  17.  
  18. Revision 0.5  1993/08/28  00:00:00  neeri
  19. Handle multiple preference files
  20.  
  21. Revision 0.4  1993/08/17  00:00:00  neeri
  22. Enable Save
  23.  
  24. Revision 0.3  1993/08/13  00:00:00  neeri
  25. Write bounds rectangles
  26.  
  27. Revision 0.2  1993/05/30  00:00:00  neeri
  28. Support Console Windows
  29.  
  30. Revision 0.1  1993/05/29  00:00:00  neeri
  31. Compiles correctly
  32.  
  33. *********************************************************************/
  34.  
  35. #include <Errors.h>
  36. #include <Resources.h>
  37. #include <Desk.h>
  38. #include <PLStringFuncs.h>
  39. #include <AppleEvents.h>
  40. #include <AERegistry.h>
  41. #include <StandardFile.h>
  42. #include <TFileSpec.h>
  43. #include <Balloons.h>
  44.  
  45. #include "MPFile.h"
  46. #include "MPSave.h"
  47.  
  48. /**-----------------------------------------------------------------------
  49.         Name:             FileError
  50.         Purpose:        Puts up an error alert.
  51.     -----------------------------------------------------------------------**/
  52.  
  53.  
  54. #if !defined(powerc) && !defined(__powerc)
  55. #pragma segment File
  56. #endif
  57.  
  58. pascal void FileError(Str255 s, Str255 f)
  59. {
  60.     short    alertResult;
  61.  
  62.     SetCursor(&qd.arrow);
  63.     ParamText(s, f, (StringPtr) "\p", (StringPtr) "\p");
  64.      alertResult = Alert(ErrorAlert, nil);
  65. }
  66.  
  67. /**-----------------------------------------------------------------------
  68.         Name:             DoClose
  69.         Purpose:        Closes a window.
  70.     -----------------------------------------------------------------------**/
  71.  
  72. #if !defined(powerc) && !defined(__powerc)
  73. #pragma segment File
  74. #endif
  75.  
  76. pascal OSErr DoClose(WindowPtr aWindow, Boolean canInteract, DescType dialogAnswer)
  77. {
  78.      DPtr    aDocument;
  79.      short   alertResult;
  80.      Str255  theName;
  81.     OSErr   myErr;
  82.  
  83.     myErr = noErr;
  84.  
  85.      if (gWCount > 0) {
  86.         aDocument = DPtrFromWindowPtr(aWindow);
  87.  
  88.         if (aDocument->kind == kDocumentWindow) {
  89.             if (aDocument->dirty)
  90.                 if (canInteract && (dialogAnswer==kAEAsk)) {
  91.                     if (aDocument->u.reg.everSaved == false)
  92.                         GetWTitle(aWindow, theName); /* Pick it up as a script may have changed it */
  93.                     else
  94.                         PLstrcpy(theName, aDocument->theFileName);
  95.     
  96.                     ParamText(theName, (StringPtr) "\p", (StringPtr) "\p", (StringPtr) "\p");
  97.                     SetCursor(&qd.arrow);
  98.                     alertResult = Alert(SaveAlert, nil);
  99.                     switch (alertResult) {
  100.                     case aaSave:
  101.                         myErr = SaveAskingName(aDocument, canInteract);
  102.                         break;
  103.     
  104.                     case aaCancel:
  105.                         return userCanceledErr;
  106.     
  107.                     case aaDiscard:
  108.                         aDocument->dirty = false;
  109.                         break;
  110.                     }
  111.                 } else {
  112.                     if (dialogAnswer==kAEYes)
  113.                         myErr = SaveAskingName(aDocument, canInteract);
  114.                     else
  115.                         myErr = noErr; /* Don't save */
  116.                 }
  117.                 
  118.             if (!myErr) {
  119. #ifndef RUNTIME
  120.                 if (aDocument->kind == kDocumentWindow && aDocument->u.reg.numSections)
  121.                     DeRegisterAllSections(aDocument);
  122. #endif
  123.  
  124.                 CloseMyWindow(aWindow);
  125.             }
  126.         } else if (aDocument->u.cons.selected) {
  127.             if (!gQuitting) {
  128.                 SysBeep(0);
  129.     
  130.                 return userCanceledErr;
  131.             }
  132.         } else 
  133.             SaveConsole(aDocument);
  134.     } else
  135.         myErr = errAEIllegalIndex;
  136.  
  137.     return myErr;
  138. }
  139.  
  140. #if !defined(powerc) && !defined(__powerc)
  141. #pragma segment File
  142. #endif
  143.  
  144. //  DoQuit
  145. //  saveOpt - one of kAEAsk,kAEYes,kAENo
  146. //  if kAEYes or kAEAsk then AEInteactWithUser should have been called
  147. //  before DoQuit. Assumes that it can interact if it needs to.
  148.  
  149. pascal void DoQuit(DescType saveOpt)
  150. {
  151.     WindowPeek    aWindow;
  152.     WindowPeek    nextWindow;
  153.     short            theKind;
  154.  
  155.     if (gRunningPerl && (Alert(AbortAlert, nil) == 2))
  156.         return;
  157.         
  158.     gQuitting = true;
  159.  
  160.     for (aWindow = (WindowPeek) FrontWindow(); aWindow; aWindow = nextWindow) {
  161.         nextWindow = aWindow->nextWindow;
  162.         if (Ours((WindowPtr) aWindow)) {
  163.             if (DoClose((WindowPtr) aWindow, true, saveOpt)) {
  164.                 gQuitting = false;
  165.                 
  166.                 return;
  167.             }
  168.         } else {
  169.             theKind = aWindow->windowKind;
  170.             if (theKind < 0)
  171.                 CloseDeskAcc(theKind);
  172.         }
  173.     }
  174. }
  175.  
  176. #ifndef RUNTIME
  177. pascal Boolean GetFileFilter(CInfoPBPtr pb)
  178. {
  179.     switch (GetDocTypeFromInfo(pb)) {
  180.     case kPreferenceDoc:
  181.         /* We don't want preference files here. Maybe we should */
  182.     case kUnknownDoc:
  183.         return true;
  184.     default:
  185.         return false;
  186.     }
  187. }
  188.  
  189. #if USESROUTINEDESCRIPTORS
  190. RoutineDescriptor    uGetFileFilter = 
  191.         BUILD_ROUTINE_DESCRIPTOR(uppFileFilterProcInfo, GetFileFilter);
  192. #else
  193. #define uGetFileFilter *(FileFilterUPP)&GetFileFilter
  194. #endif
  195.  
  196. #else
  197. pascal Boolean GetFileFilter(ParmBlkPtr info)
  198. {
  199.     switch (info->fileParam.ioFlFndrInfo.fdType) {
  200.     case 'APPL':
  201.         switch (info->fileParam.ioFlFndrInfo.fdCreator) {
  202.         case MPRtSig:
  203.             return false;
  204.         case MPAppSig:
  205.             return !info->fileParam.ioFlLgLen;
  206.         default:
  207.             return true;
  208.         }
  209.     case 'TEXT':
  210.         return false;
  211.     default:
  212.         return true;
  213.     }
  214. }
  215. #endif
  216.  
  217. pascal OSErr GetFile(FSSpec *theFSSpec)
  218. {
  219. #ifndef RUNTIME
  220.     StandardFileReply  reply;
  221.  
  222.     BuildSEList();
  223.     
  224.     StandardGetFile(&uGetFileFilter, MacPerlFileTypeCount, MacPerlFileTypes, &reply);
  225.  
  226.     if (reply.sfGood) {
  227.         *theFSSpec = reply.sfFile;
  228.         return noErr;
  229.     } else
  230.         return userCanceledErr;
  231.         
  232. #else
  233.  
  234.     SFTypeList     myTypes = {'TEXT', 'APPL'};
  235.     SFReply          reply;
  236.     Point            where;
  237.  
  238.     where.h = where.v = 75;
  239.  
  240.     SFGetFile(
  241.         where, (StringPtr) "\p", 
  242.         (FileFilterUPP) GetFileFilter, 2, myTypes, 
  243.         (DlgHookProcPtr) nil,
  244.         &reply);
  245.  
  246.     if (reply.good)
  247.         return WD2FSSpec(reply.vRefNum, reply.fName, theFSSpec);
  248.     else
  249.         return userCanceledErr;
  250.         
  251. #endif
  252. }
  253.  
  254. #if !defined(powerc) && !defined(__powerc)
  255. #pragma segment File
  256. #endif
  257.  
  258. pascal OSErr DoCreate(FSSpec theSpec)
  259. {
  260.     OSErr err;
  261.  
  262. #ifndef RUNTIME
  263.     err = FSpCreate(&theSpec, MPAppSig, 'TEXT', smSystemScript);
  264. #else
  265.     err = HCreate(theSpec.vRefNum, theSpec.parID, theSpec.name, MPAppSig, 'TEXT');
  266. #endif
  267.  
  268.     if (!err)
  269.         HCreateResFile(theSpec.vRefNum, theSpec.parID, theSpec.name);
  270.     else
  271.         ShowError((StringPtr) "\pCreating", err);
  272.  
  273.     return err;
  274. }
  275.  
  276. pascal OSErr SaveConsole(DPtr doc)
  277. {
  278.     OSErr            err;
  279.     short       resFile;
  280.     HHandle     theHHandle;
  281.     Str255        title;
  282.     Boolean        existing;
  283.     
  284.     if (gPrefsFile) {
  285.         resFile    =    CurResFile();
  286.         UseResFile(gPrefsFile);
  287.         GetWTitle(doc->theWindow, title);
  288.         
  289.         if (theHHandle = (HHandle) Get1NamedResource('TFSS', title)) {
  290.             existing = true;
  291.         } else {
  292.             existing = false;
  293.             theHHandle = (HHandle)NewHandle(sizeof(HeaderRec));
  294.         }
  295.         
  296.         HLock((Handle)theHHandle);
  297.     
  298.         (*theHHandle)->theRect     = doc->theWindow->portRect;
  299.         OffsetRect(
  300.             &(*theHHandle)->theRect,
  301.             -doc->theWindow->portBits.bounds.left,
  302.             -doc->theWindow->portBits.bounds.top);
  303.             
  304.         GetFontName((*(doc->theText))->txFont, (StringPtr) &(*theHHandle)->theFont);
  305.         
  306.         (*theHHandle)->theSize     = (*(doc->theText))->txSize;
  307.         (*theHHandle)->lastID      = 0;
  308.         (*theHHandle)->numSections = 0;
  309.     
  310.         HUnlock((Handle)theHHandle);
  311.     
  312.         if (existing) {
  313.             ChangedResource((Handle) theHHandle);
  314.             WriteResource((Handle) theHHandle);
  315.             UpdateResFile(gPrefsFile);
  316.         } else {
  317.             AddResource((Handle)theHHandle, 'TFSS', Unique1ID('TFSS'), title);
  318.         }
  319.         
  320.         err = ResError();
  321.         
  322.         UseResFile(resFile);
  323.     }
  324.     
  325.     if (doc->u.cons.cookie) {
  326.         /* We might need this window again. */
  327.         DoHideWindow(doc->theWindow);
  328.         TESetSelect(0, 32767, doc->theText);
  329.         TEDelete(doc->theText);
  330.     
  331.         if (doc->u.cons.fence < 32767)
  332.             doc->u.cons.fence    = 0;
  333.     } else /* Done with this window */
  334.         CloseMyWindow(doc->theWindow);
  335.     
  336.     return err;
  337. } 
  338.  
  339. pascal void ApplySettings(DPtr doc, HPtr settings)
  340. {
  341.     short        fNum;
  342.     FontInfo    info;
  343.     Rect        bounds;
  344.     
  345.     GetFNum(settings->theFont, &fNum);
  346.     SetPort(doc->theWindow);
  347.     TextFont(fNum);
  348.     TextSize(settings->theSize);
  349.     GetFontInfo(&info);
  350.     
  351.     (*doc->theText)->txFont         = fNum;
  352.     (*doc->theText)->txSize         = settings->theSize;
  353.     (*doc->theText)->lineHeight    = info.ascent+info.descent+info.leading;
  354.     (*doc->theText)->fontAscent    = info.ascent;
  355.     
  356.     bounds.top                            = settings->theRect.top - 13;
  357.     bounds.left                            = settings->theRect.left + 5;
  358.     bounds.bottom                        = settings->theRect.top  - 5;
  359.     bounds.right                        = settings->theRect.right - 5;
  360.     
  361.     if (settings->theRect.right > settings->theRect.left + 50 &&
  362.         settings->theRect.bottom > settings->theRect.top  + 50 &&
  363.         RectInRgn(&bounds, GetGrayRgn())
  364.     ) {
  365.         MoveWindow(doc->theWindow, settings->theRect.left, settings->theRect.top, false);
  366.         SizeWindow(
  367.             doc->theWindow,
  368.             settings->theRect.right - settings->theRect.left,
  369.             settings->theRect.bottom - settings->theRect.top,
  370.             false);
  371.     }
  372.         
  373.     ResizeWindow(doc);
  374. }
  375.  
  376. pascal void RestoreConsole(DPtr doc)
  377. {
  378.     short       resFile;
  379.     HHandle     theHHandle;
  380.     Str255        title;
  381.     
  382.     if (!gPrefsFile)
  383.         return;
  384.         
  385.     resFile    =    CurResFile();
  386.     UseResFile(gPrefsFile);
  387.     GetWTitle(doc->theWindow, title);
  388.     
  389.     if (theHHandle = (HHandle) Get1NamedResource('TFSS', title)) {
  390.          HLock((Handle)theHHandle);
  391.         
  392.         ApplySettings(doc, *theHHandle);
  393.         
  394.         HUnlock((Handle)theHHandle);
  395.     }
  396.     
  397.     UseResFile(resFile);
  398. }
  399.  
  400.  
  401. /** -----------------------------------------------------------------------
  402.         Name:         GetFileContents
  403.         Purpose:        Opens the document specified by theFSSpec and puts
  404.                         the contents into theDocument.
  405.      -----------------------------------------------------------------------**/
  406.  
  407. #if !defined(powerc) && !defined(__powerc)
  408. #pragma segment File
  409. #endif
  410.  
  411. pascal OSErr GetFileContents(FSSpec spec, DPtr theDocument)
  412. {
  413.     long            theSize;
  414.     short            oldRes;
  415.     short            resFile;
  416.     short            refNum;
  417.     OSErr            err;
  418.     HHandle        aHandle;
  419.     Handle        gHandle;
  420.  
  421.     oldRes    =    CurResFile();
  422.     resFile     =    HOpenResFile(spec.vRefNum, spec.parID, spec.name, fsRdPerm);
  423.     
  424.     theDocument->u.reg.everLoaded = true;
  425.     theDocument->u.reg.origFSSpec = spec;
  426.     
  427.     if (theDocument->inDataFork) {
  428. #ifndef RUNTIME
  429.         if (err = HOpenDF(spec.vRefNum, spec.parID, spec.name, fsRdPerm, &refNum)) {
  430.             ShowError((StringPtr) "\pread file - HOpenDF", err);
  431. #else
  432.         if (err = HOpen(spec.vRefNum, spec.parID, spec.name, fsRdPerm, &refNum)) {
  433.             ShowError((StringPtr) "\pread file - HOpen", err);
  434. #endif
  435.             refNum = 0;
  436.             
  437.             goto giveUp;
  438.         }
  439.     
  440.         if (err = GetEOF(refNum, &theSize))
  441.             goto giveUp;
  442.  
  443.           gHandle = NewHandle(theSize);
  444.  
  445.         HLock(gHandle);
  446.         if (err = FSRead(refNum, &theSize, *gHandle))
  447.             return err;
  448.         HUnlock(gHandle);
  449.         FSClose(refNum);
  450.     } else {
  451.         gHandle    =    Get1NamedResource('TEXT', (StringPtr) "\p!");
  452.         
  453.         if (gHandle) 
  454.             DetachResource(gHandle);
  455.         else {
  456.             err = ResError();
  457.             
  458.             goto giveUp;
  459.         }
  460.     }
  461.  
  462.     theDocument->u.reg.numSections = 0;
  463.  
  464.     if (resFile != -1) {
  465.         aHandle = nil;
  466.  
  467.         if (Count1Resources('TFSS'))
  468.             aHandle = (HHandle)Get1Resource('TFSS', 255);
  469.  
  470.         if (aHandle) {
  471.             theDocument->u.reg.numSections = (*aHandle)->numSections;
  472.             
  473.             HLock((Handle) aHandle);
  474.             ApplySettings(theDocument, *aHandle);
  475.         }
  476.  
  477.         /*
  478.             If there is a print record saved, ditch the old one
  479.             created by new document and fill this one in
  480.         */
  481.         if (Count1Resources('TFSP')) {
  482.             if (theDocument->thePrintSetup)
  483.                 DisposHandle((Handle)theDocument->thePrintSetup);
  484.  
  485.             theDocument->thePrintSetup = (THPrint)Get1Resource('TFSP', 255);
  486.               HandToHand((Handle *)&theDocument->thePrintSetup);
  487.  
  488.             PrValidate(theDocument->thePrintSetup);
  489.         }
  490.  
  491. #ifndef RUNTIME
  492.         if (theDocument->u.reg.numSections) {
  493.             ReadSectionRecords(theDocument);
  494.             ReadAllSectionResources(theDocument);
  495.         }
  496. #else
  497.         theDocument->u.reg.numSections    =    0;
  498. #endif
  499.  
  500.         CloseResFile(resFile);
  501.  
  502.         if (err = ResError()) {
  503.             ShowError((StringPtr) "\pread file- CloseResFile", err);
  504.             return err;
  505.         }
  506.     }
  507.  
  508.     HLock(gHandle);
  509.     if (GetHandleSize(gHandle) > 32000) {
  510.         PtrToXHand(
  511.             *gHandle, 
  512.             (*theDocument->theText)->hText, 
  513.             GetHandleSize(gHandle));
  514.         
  515.         err = elvisErr;
  516.     } else
  517.         TESetText(*gHandle, GetHandleSize(gHandle), theDocument->theText);
  518.     DisposHandle(gHandle);
  519.  
  520.     if (err == fnfErr)
  521.         return noErr;
  522.     else
  523.           return err;
  524.  
  525. giveUp:    
  526.     if (refNum)
  527.         FSClose(refNum);
  528.         
  529.     if (resFile > -1)
  530.         CloseResFile(resFile);
  531.     
  532.     UseResFile(oldRes);
  533.     
  534.     return err;
  535. } /* GetFileContents */
  536.  
  537.  
  538. #if !defined(powerc) && !defined(__powerc)
  539. #pragma segment File
  540. #endif
  541.  
  542. pascal OSErr SaveAskingName(DPtr aDocument, Boolean canInteract)
  543. {
  544.     OSErr    myErr;
  545.  
  546.     if (aDocument->kind != kDocumentWindow || !aDocument->u.reg.everSaved) {
  547.  
  548.         if (canInteract) {
  549.             if (myErr = GetFileNameToSaveAs(aDocument))
  550.                 return myErr;
  551.  
  552.             if (myErr = SaveWithoutTemp(aDocument, aDocument->theFSSpec))
  553.                 return myErr;            
  554. #ifndef RUNTIME
  555.             AssocAllSections(aDocument);
  556. #endif
  557.  
  558.             return noErr;
  559.         } else
  560.             return errAENoUserInteraction;
  561.  
  562.     } else
  563.         return SaveUsingTemp(aDocument);
  564. }
  565.  
  566. #if !defined(powerc) && !defined(__powerc)
  567. #pragma segment File
  568. #endif
  569.  
  570. pascal OSErr SaveUsingTemp(DPtr theDocument)
  571. {
  572.     Str255    tempName;
  573.     OSErr        err;
  574.     FSSpec    tempFSSpec;
  575.  
  576.     /*save the file to disk using a temporary file*/
  577.     /*this is the recommended way of doing things*/
  578.     /*first write out the file to disk using a temporary filename*/
  579.     /*if it is sucessfully written, exchange the temporary file with the last one saved*/
  580.     /*then delete the temporary file- so if anything goes wrong, the original version is still there*/
  581.     /*first generate the temporary filename*/
  582.  
  583.     GetTempFSSpec(theDocument, &tempFSSpec);
  584.  
  585.     if (err = DoCreate(tempFSSpec))
  586.         return err;
  587.  
  588.     if (err = DoSave(theDocument, tempFSSpec))
  589.         return err;
  590.     
  591. #ifndef RUNTIME
  592.     if (err = FSpExchangeFiles(&tempFSSpec, &theDocument->theFSSpec))
  593.         return err;
  594.     
  595.     /*we've exchanged the files, now delete the temporary one*/
  596.  
  597.     FSpDelete(&tempFSSpec);
  598. #else
  599.     err = FSpSmartMove(&tempFSSpec, &theDocument->theFSSpec);
  600. #endif
  601.     
  602.     if (!err && theDocument->kind == kDocumentWindow) {
  603.         theDocument->dirty                 = false;
  604.         theDocument->u.reg.everSaved     = true;
  605.         theDocument->u.reg.origFSSpec = theDocument->theFSSpec;
  606.     }
  607.  
  608.     return err;
  609. }
  610.  
  611. pascal OSErr SaveWithoutTemp(DPtr theDocument, FSSpec spec)
  612. {
  613.     OSErr        err;
  614.     
  615.     if (err = DoSave(theDocument, spec))
  616.         return err;
  617.  
  618.     if (theDocument->kind == kDocumentWindow) {
  619.         theDocument->dirty                 = false;
  620.         theDocument->u.reg.everSaved     = true;
  621.         theDocument->u.reg.origFSSpec = theDocument->theFSSpec = spec;
  622.                 
  623.         SetWTitle(theDocument->theWindow, theDocument->theFSSpec.name);
  624.     }
  625.     
  626.     return noErr;
  627. }
  628.  
  629. #if !defined(powerc) && !defined(__powerc)
  630. #pragma segment File
  631. #endif
  632.  
  633. pascal short SaveScriptHook(short item, DialogPtr dlg, void * params)
  634. {
  635.     short                kind;
  636.     ControlHandle    type;
  637.     MenuHandle        typeMenu;
  638.     Rect                r;
  639.     DPtr                doc = (DPtr) params;
  640.     
  641.     if (GetWRefCon(dlg) != 'stdf')
  642.         return item;
  643.         
  644.     switch (item) {
  645.     case sfHookFirstCall:
  646.         GetDItem(dlg, ssd_Type, &kind, (Handle *) &type, &r);
  647.         typeMenu = (*(PopupPrivateDataHandle)(*type)->contrlData)->mHandle;
  648.         
  649.         AddExtensionsToMenu(typeMenu);
  650.         SetControlMaximum(type, CountMItems(typeMenu));
  651.         SetCtlValue(type, Type2Menu(doc->type));
  652.         
  653.         return sfHookFirstCall;
  654.     case ssd_Type:
  655.         GetDItem(dlg, item, &kind, (Handle *) &type, &r);
  656.         
  657.         doc->type = (DocType) Menu2Type(GetCtlValue(type));
  658.         
  659.         return sfHookNullEvent;
  660.     default:
  661.         return item;
  662.     }
  663. }
  664.  
  665. #if USESROUTINEDESCRIPTORS
  666. RoutineDescriptor    uSaveScriptHook = 
  667.         BUILD_ROUTINE_DESCRIPTOR(uppDlgHookYDProcInfo, SaveScriptHook);
  668. #else
  669. #define uSaveScriptHook *(DlgHookYDUPP)&SaveScriptHook
  670. #endif
  671.  
  672. /*
  673.     Fills in the document record with the user chosen destination
  674. */
  675.  
  676. pascal OSErr GetFileNameToSaveAs(DPtr theDocument)
  677. {
  678. #ifndef RUNTIME
  679.     OSErr                    err;
  680.     StandardFileReply    reply;
  681.     Str255            suggestName;
  682.     Point                    where;
  683.     
  684.     where.h = where.v = -1;
  685.  
  686.     GetWTitle(theDocument->theWindow, suggestName);
  687.  
  688. #ifndef RUNTIME
  689.     HMSetDialogResID(SaveScriptDialog);
  690. #endif
  691.     CustomPutFile(
  692.         (StringPtr) "\pSave Document As:", suggestName, &reply,
  693.         SaveScriptDialog,
  694.         where,
  695.         &uSaveScriptHook,
  696.         (ModalFilterYDUPP) nil,
  697.         nil,
  698.         (ActivateYDUPP) nil,
  699.         theDocument);
  700. #ifndef RUNTIME
  701.     HMSetDialogResID(-1);
  702. #endif
  703.  
  704.     if (reply.sfGood)
  705.         switch (err = FSpDelete(&reply.sfFile)) {
  706.         case noErr:
  707.         case fnfErr:
  708.             theDocument->theFSSpec = reply.sfFile;
  709.             PLstrcpy(theDocument->theFileName, reply.sfFile.name);
  710.  
  711.             return noErr;
  712.         default:
  713.             return err;
  714.         }
  715.     else
  716.         return userCanceledErr;
  717. #else
  718.     OSErr        err;
  719.     SFReply    reply;
  720.     Str255   suggestName;
  721.     Point        where;
  722.  
  723.     where.h = where.v = 75;
  724.     
  725.     GetWTitle(theDocument->theWindow, suggestName);
  726.  
  727.     SFPutFile(
  728.         where, (StringPtr) "\pSave Document As:", 
  729.         suggestName, (DlgHookProcPtr) nil,
  730.         &reply);
  731.     
  732.     if (reply.good) {
  733.         FSSpec    spec;
  734.         
  735.         if (err = WD2FSSpec(reply.vRefNum, reply.fName, &spec))
  736.             return err;
  737.         switch (err = HDelete(spec.vRefNum, spec.parID, spec.name)) {
  738.         case noErr:
  739.         case fnfErr:
  740.             theDocument->theFSSpec = spec;
  741.             PLstrcpy(theDocument->theFileName, spec.name);
  742.  
  743.             return noErr;
  744.         default:
  745.             return err;
  746.         }
  747.     } else
  748.         return userCanceledErr;
  749. #endif
  750. } /* GetFileNameToSaveAs */
  751.  
  752. #if !defined(powerc) && !defined(__powerc)
  753. #pragma segment File
  754. #endif
  755.  
  756. pascal DPtr MakeOldDoc(FSSpec aFSSpec, DocType type)
  757. {
  758.     DPtr          theDocument;
  759.     
  760.     theDocument = NewDocument(true, kDocumentWindow);
  761.  
  762.     SetWTitle(theDocument->theWindow, aFSSpec.name);
  763.  
  764.     SetPort(theDocument->theWindow);
  765.  
  766.     theDocument->theFSSpec   = aFSSpec;
  767.  
  768.     PLstrcpy(theDocument->theFileName, aFSSpec.name);
  769.  
  770.     theDocument->dirty               = false;
  771.     theDocument->inDataFork            = type == kPlainTextDoc || type == kOldRuntime6Doc;
  772.     
  773. #ifndef RUNTIME
  774.     /* We *can* open documents created by unknown save extensions, but we can't
  775.        save them again 
  776.     */
  777.     if (CanSaveAs(type)) {
  778.         theDocument->type                 = type;
  779.         theDocument->u.reg.everSaved    = true;
  780.     } else {
  781.         theDocument->type                    = (type == kOldRuntime6Doc) ? kRuntime6Doc : kPlainTextDoc;
  782.         theDocument->u.reg.everSaved    = false;
  783.     }
  784. #else
  785.     theDocument->type                    = kPlainTextDoc;
  786.     theDocument->u.reg.everSaved    = (type == kPlainTextDoc);
  787. #endif
  788.  
  789.     return theDocument;
  790. }
  791.  
  792. pascal OSErr OpenOld(FSSpec aFSSpec, DocType type)
  793. {
  794.     DPtr          theDocument;
  795.     OSErr         fileErr;
  796.     WindowPtr    win;
  797.  
  798.     if (win = AlreadyOpen(&aFSSpec, nil)) {
  799.         SelectWindow(win);
  800.         
  801.         return noErr;
  802.     }
  803.     
  804.     theDocument    =    MakeOldDoc(aFSSpec, type);
  805.     
  806.     fileErr = GetFileContents(aFSSpec, theDocument);
  807.  
  808.     if (!fileErr) {
  809.         ResizeWindow(theDocument);
  810.         DoShowWindow(theDocument->theWindow);
  811.     } else {
  812.         if (fileErr == elvisErr) {
  813.             theDocument->u.reg.everSaved    = false;
  814. #ifdef RUNTIME
  815.             if (AEInteractWithUser(kAEDefaultTimeout, nil, nil))
  816. #endif
  817.                 if (Alert(ElvisAlert, nil) == 1)
  818.                     SaveAskingName(theDocument, true);
  819.         } else
  820.             FileError((StringPtr) "\pError Opening ", aFSSpec.name);
  821.         
  822.         CloseMyWindow(theDocument->theWindow);
  823.     }
  824.  
  825.     return fileErr;
  826. } /* OpenOld */
  827.  
  828. pascal OSErr File2File(FSSpec aFSSpec, DocType type, FSSpec toFSSpec, DocType newtype)
  829. {
  830.     DPtr          theDocument;
  831.     OSErr         fileErr;
  832.  
  833.     theDocument    =    MakeOldDoc(aFSSpec, type);
  834.     
  835.     switch (fileErr = GetFileContents(aFSSpec, theDocument)) {
  836.     case elvisErr:
  837.         fileErr = noErr;
  838.         /* Fall through */
  839.     case noErr:
  840.         theDocument->type = newtype;
  841.         theDocument->u.reg.everSaved    = false;
  842.         if (SameFSSpec(&aFSSpec, &toFSSpec))
  843.             fileErr = SaveUsingTemp(theDocument);
  844.         else
  845.             fileErr = SaveWithoutTemp(theDocument, toFSSpec);
  846.         
  847.         /* Fall through */
  848.     default:
  849.         CloseMyWindow(theDocument->theWindow);
  850.     }
  851.  
  852.     return fileErr;
  853. } /* File2File */
  854.  
  855. pascal OSErr Handle2File(Handle text, FSSpec toFSSpec, DocType newtype)
  856. {
  857.     DPtr          theDocument;
  858.     OSErr         fileErr;
  859.  
  860.     theDocument = NewDocument(true, kDocumentWindow);
  861.     
  862.     HLock(text);
  863.     PtrToXHand(*text, (*theDocument->theText)->hText, GetHandleSize(text));
  864.     HUnlock(text);
  865.     
  866.     theDocument->u.reg.everSaved    = false;
  867.     theDocument->type                 = newtype;
  868.  
  869.     fileErr = SaveWithoutTemp(theDocument, toFSSpec);
  870.     
  871.     CloseMyWindow(theDocument->theWindow);
  872.  
  873.     return fileErr;
  874. } /* Handle2File */
  875.  
  876. pascal DocType GetDocTypeFromFile(short vRefNum, long dirID, StringPtr name)
  877. {
  878.     short            resFile;
  879.     short            nuFile;
  880.     OSType    **    rtType;
  881.     DocType        type    =    kUnknownDoc;
  882.     
  883.     resFile    = CurResFile();
  884.     nuFile    = HOpenResFile(vRefNum, dirID, name, fsRdPerm);
  885.     
  886.     if (nuFile != -1) {
  887.         if (rtType = (OSType **) Get1Resource('MrPL', 128))
  888.             type = **(DocType **) rtType;
  889.             
  890.         CloseResFile(nuFile);
  891.     }
  892.     UseResFile(resFile);
  893.     
  894.     return type;
  895. }
  896.  
  897. pascal DocType GetDocTypeFromInfo(CInfoPBPtr info)
  898. {
  899.     DocType        type    =    kUnknownDoc;
  900.     
  901.     switch (info->hFileInfo.ioFlFndrInfo.fdType) {
  902.     case 'APPL':
  903.         if (info->hFileInfo.ioFlFndrInfo.fdCreator == MPAppSig) 
  904.             /* A heuristic to separate old runtimes from PowerPC executables */
  905.             if (info->hFileInfo.ioFlLgLen && info->hFileInfo.ioFlLgLen < 100000)
  906.                 return kOldRuntime6Doc; 
  907.         
  908.         break;
  909.     case 'TEXT':
  910.         return kPlainTextDoc;
  911.     case 'pref':
  912.         switch (info->hFileInfo.ioFlFndrInfo.fdCreator) {
  913.         case MPAppSig:
  914.         case MPRtSig:
  915.             return kPreferenceDoc;
  916.         }
  917.         break;
  918.     default:
  919.         break;
  920.     }
  921.     
  922.     /* Ultimately, with save extensions, every file could be ours */
  923.     return GetDocTypeFromFile(
  924.         info->hFileInfo.ioVRefNum, 
  925.         info->hFileInfo.ioFlParID, 
  926.         info->hFileInfo.ioNamePtr);;
  927. }
  928.  
  929. pascal DocType GetDocType(FSSpec * spec)
  930. {
  931.     CInfoPBRec    info;
  932.  
  933.     if (FSpCatInfo(spec, &info))
  934.         return kUnknownDoc;
  935.     else
  936.         return GetDocTypeFromInfo(&info);
  937. }